/**
 * 作者：
 * 创建时间：2012-6-26 下午2:25:04
 */
package dragon.model.bizObject;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;

import dragon.core.util.GlobalParameter;
import dragon.core.util.StringUtils;
import dragon.model.base.Model;
import dragon.model.base.ModelDescribe;
import dragon.model.fieldTemplate.FieldTemplate;
import dragon.model.fieldTemplate.FieldTemplateType;
import dragon.model.intercept.Interceptor;

/**
 * 业务对象定义 包含了字段，过程等定义
 */
public class BizObject extends Model {

	/**
	 * 增加页面弹出窗口宽度
	 */
	@ModelDescribe(annotation = "增加页面弹出窗口宽度")
	private int addWindowWidth = 800;

	/**
	 * 增加页面弹出窗口高度
	 */
	@ModelDescribe(annotation = "增加页面弹出窗口高度")
	private int addWindowHeight = 500;

	/**
	 * 修改页面弹出窗口宽度
	 */
	@ModelDescribe(annotation = "修改页面弹出窗口宽度")
	private int modWindowWidth = 800;

	/**
	 * 修改页面弹出窗口高度
	 */
	@ModelDescribe(annotation = "修改页面弹出窗口高度")
	private int modWindowHeight = 500;

	/**
	 * 查看页面弹出窗口宽度
	 */
	@ModelDescribe(annotation = "查看页面弹出窗口宽度")
	private int viewWindowWidth = 800;

	/**
	 * 查看页面弹出窗口高度
	 */
	@ModelDescribe(annotation = "查看页面弹出窗口高度")
	private int viewWindowHeight = 500;

	/**
	 * 是否允许窗口最大化(否0，是1)
	 */
	@ModelDescribe(annotation = "是否允许窗口最大化(否0，是1)")
	private int maximizable = 1;

	/**
	 * 打开窗口后是否最大化(否0，是1)
	 */
	@ModelDescribe(annotation = "打开窗口后是否最大化(否0，是1)")
	private int maximize = 0;

	/**
	 * 是否启用分页(否0，是1)
	 */
	@ModelDescribe(annotation = "是否启用分页(否0，是1)")
	private int pagination = 1;

	/**
	 * 分页数据控制，每页显示记录默认条数
	 */
	@ModelDescribe(annotation = "分页数据控制，每页显示记录默认条数")
	private int pageSize = 15;

	/**
	 * 控制可选择的分页条数
	 */
	@ModelDescribe(annotation = "控制可选择的分页条数")
	private String pageList = "15,30,50";

	/**
	 * 是否启用服务端排序(否0，是1)<br>
	 * TODO:暂时未启用(预留)
	 */
	@ModelDescribe(annotation = "是否启用服务端排序(否0，是1)<br>暂时未启用(预留)")
	private int remoteSort = 0;

	/**
	 * 是否启用单选控制(否0，是1)
	 */
	@ModelDescribe(annotation = "是否启用单选控制(否0，是1)")
	private int singleSelect = 0;

	/**
	 * 是否显示行号(否0，是1)
	 */
	@ModelDescribe(annotation = "是否显示行号(否0，是1)")
	private int rownumbers = 1;

	/**
	 * 数据列表视图模板，用于渲染的JSP页面相对路径，默认采用标准的数据列表视图
	 */
	@ModelDescribe(annotation = "数据列表视图模板，用于渲染的JSP页面相对路径，默认采用标准的数据列表视图")
	private String listPage = GlobalParameter.LIST;

	/**
	 * 树形结构主从表模型的主页面模板
	 */
	@ModelDescribe(annotation = "树形结构主从表模型的主页面模板")
	private String treePage;

	/**
	 * 是否启用拖拽功能，树形列表特有
	 */
	@ModelDescribe(annotation = "是否启用拖拽功能，树形列表特有")
	private int dnd;

	/**
	 * 如果启用了拖拽功能，则需要提供拖拽的处理程序(url)，树形列表特有
	 */
	@ModelDescribe(annotation = "如果启用了拖拽功能，则需要提供拖拽的处理程序(url)，树形列表特有")
	private String dndAction;

	/**
	 * 数据增加视图模板，用于渲染的JSP页面相对路径，默认采用标准的数据增加视图
	 */
	@ModelDescribe(annotation = "数据增加视图模板，用于渲染的JSP页面相对路径，默认采用标准的数据增加视图")
	private String addPage = GlobalParameter.ADD;

	/**
	 * 数据修改视图模板，用于渲染的JSP页面相对路径，默认采用标准的数据修改视图
	 */
	@ModelDescribe(annotation = "数据修改视图模板，用于渲染的JSP页面相对路径，默认采用标准的数据修改视图")
	private String modPage = GlobalParameter.MOD;

	/**
	 * 数据查看视图模板，用于渲染的JSP页面相对路径，默认采用标准的数据修改视图
	 */
	@ModelDescribe(annotation = "数据查看视图模板，用于渲染的JSP页面相对路径，默认采用标准的数据修改视图")
	private String viewPage = GlobalParameter.VIEW;

	/**
	 * SQL(SQL中可以用占位符(可以从页面参数，系统变量，用户属性等查找)，用于动态设置查询条件)<br>
	 * "@{}"代表字段引用同名的业务字段<br>
	 * TODO:更多占位符需要后续处理<br>
	 * SQL分为 SELECT,VIEW,INSERT,UPDATE,UPDATEQUERY,DELETE六类(参见dragon.model.bizObject.SQLType)<br>
	 * SELECT,UPDATEQUERY,VIEW下只允许有一条语句，其它类型的SQL支持多条语句，以分号";"分割
	 */
	@ModelDescribe(annotation = "SQL分为 SELECT,VIEW,INSERT,UPDATE,UPDATEQUERY,DELETE六类(参见dragon.model.bizObject.SQLType)<br>SELECT,UPDATEQUERY,VIEW下只允许有一条语句，其它类型的SQL支持多条语句，以分号;分割")
	private Map<SQLType, String[]> sql;

	/**
	 * 数据集查询语句，运行时字段，存储sql中的SELECT类型语句
	 */
	@ModelDescribe(annotation = "数据集查询语句，运行时字段，存储sql中的SELECT类型语句", runtime = true)
	private String selectSQL;

	/**
	 * 单条数据查询语句，运行时字段，存储sql中的VIEW类型语句
	 */
	@ModelDescribe(annotation = "单条数据查询语句，运行时字段，存储sql中的VIEW类型语句", runtime = true)
	private String viewSQL;

	/**
	 * 修改页面数据查询语句，运行时字段，存储sql中的UPDATEQUERY类型语句
	 */
	@ModelDescribe(annotation = "修改页面数据查询语句，运行时字段，存储sql中的UPDATEQUERY类型语句", runtime = true)
	private String updateQuerySQL;

	/**
	 * 新增语句(已处理为预处理语句)，运行时字段，存储sql中的INSERT类型语句
	 */
	@ModelDescribe(annotation = "新增语句(已处理为预处理语句)，运行时字段，存储sql中的INSERT类型语句", runtime = true)
	private String[] insertSQL;

	/**
	 * 修改语句(已处理为预处理语句)，运行时字段，存储sql中的UPDATE类型语句
	 */
	@ModelDescribe(annotation = "修改语句(已处理为预处理语句)，运行时字段，存储sql中的UPDATE类型语句", runtime = true)
	private String[] updateSQL;

	/**
	 * 删除语句(已处理为预处理语句)，运行时字段，存储sql中的DELETE类型语句
	 */
	@ModelDescribe(annotation = "删除语句(已处理为预处理语句)，运行时字段，存储sql中的DELETE类型语句", runtime = true)
	private String[] deleteSQL;

	/**
	 * 业务字段，多个数据表的字段集合
	 */
	@ModelDescribe(annotation = "业务字段，多个数据表的字段集合")
	private List<BizField> bizFields;

	/**
	 * 业务字段，运行时字段，用于快速定位业务字段<br>
	 * k:业务字段code,v:业务字段
	 */
	@ModelDescribe(annotation = "业务字段，运行时字段，用于快速定位业务字段<br>k:业务字段code,v:业务字段", runtime = true)
	private Map<String, BizField> bizFieldsMap;

	/**
	 * 字段绑定，运行时字段，分别记录了 新增，修改和删除语句中对应的业务字段，以及冻结和非冻结字段，主键字段<br>
	 * k:INSERT(INSERT_i,i为sql数组的下标),VIEW(VIEW_0)UPDATE(UPDATE_i),UPDATEQUERY(UPDATEQUERY_0),DELETE(DELETE_i),FROZEN,NONFROZEN,PRIMARY
	 */
	@ModelDescribe(annotation = "字段绑定，运行时字段，分别记录了 新增，修改和删除语句中对应的业务字段，以及冻结和非冻结字段，主键字段<br>k:INSERT(INSERT_i,i为sql数组的下标),VIEW(VIEW_0)UPDATE(UPDATE_i),UPDATEQUERY(UPDATEQUERY_0),DELETE(DELETE_i),FROZEN,NONFROZEN,PRIMARY", runtime = true)
	private Map<String, List<BizField>> bizFieldsBind = new HashMap<String, List<BizField>>();

	/**
	 * 查询字段，用于定义列表上方的查询条件
	 */
	@ModelDescribe(annotation = "查询字段，用于定义列表上方的查询条件")
	private List<QueryField> queryFields;

	/**
	 * 查询字段，运行时字段，用于快速定位查询字段<br>
	 * k:查询字段code,v:查询字段
	 */
	@ModelDescribe(annotation = "查询字段，运行时字段，用于快速定位查询字段<br>k:查询字段code,v:查询字段", runtime = true)
	private Map<String, QueryField> queryFieldsMap;

	/**
	 * 业务过程定义<br>
	 */
	@ModelDescribe(annotation = "业务过程定义")
	private List<BizProcess> processes;

	/**
	 * 业务过程定义，运行时字段，用于快速定位业务过程<br>
	 */
	@ModelDescribe(annotation = "业务过程定义", runtime = true)
	private Map<String, BizProcess> processMap;

	/**
	 * 依赖，主从表的从表中需要配置此字段，以设置参照属性<br>
	 * 配置depend时，需要同时配置dependParam
	 */
	@ModelDescribe(annotation = "依赖，主从表的从表中需要配置此字段，以设置参照属性<br>配置depend时，需要同时配置dependParam")
	private String depend;

	/**
	 * 依赖参数，主从表间的关系<br>
	 * k=v，k是从表业务模型中的查询字段code，v是主表业务模型中的业务字段code<br>
	 * 运行阶段，将v所表示的主表中的业务字段的值传入k所表示的从表中的查询字段上
	 */
	@ModelDescribe(annotation = "依赖参数，主从表间的关系<br>k=v，k是从表业务模型中的查询字段code，v是主表业务模型中的业务字段code<br>运行阶段，将v所表示的主表中的业务字段的值传入k所表示的从表中的查询字段上")
	private String dependParam;

	/**
	 * 是否绘制从表；对于主从结构，主表本身也是从表，如果不希望主表对象显示在从表列表中，则可以将主表配置文件中的dependShow设置为0
	 */
	@ModelDescribe(annotation = "是否绘制从表(否0，是1；默认1)；对于主从结构，主表本身也是从表，如果不希望主表对象显示在从表列表中，则可以将主表配置文件中的dependShow设置为0")
	private int dependShow = 1;

	/**
	 * 此业务模型对象(从表)依赖的其它业务模型对象(主表)<br>
	 * 运行时字段
	 */
	@ModelDescribe(annotation = "此业务模型对象(从表)依赖的其它业务模型对象(主表)<br>运行时字段", runtime = true)
	private BizObject dependon;

	/**
	 * 依赖于此业务模型对象(主表)的其它业务模型对象(从表)<br>
	 * 默认一个业务对象可以被多个其它业务对象依赖<br>
	 * 运行时字段
	 */
	@ModelDescribe(annotation = "依赖于此业务模型对象(主表)的其它业务模型对象(从表)<br>默认一个业务对象可以被多个其它业务对象依赖<br>运行时字段", runtime = true)
	private List<BizObject> dependby;

	/**
	 * 依赖参数，k
	 */
	@ModelDescribe(annotation = "依赖参数，k", runtime = true)
	private String dependParamK;

	/**
	 * 依赖参数，v
	 */
	@ModelDescribe(annotation = "依赖参数，v", runtime = true)
	private String dependParamV;

	/**
	 * 表单的每一行中展现字段最多的数量
	 */
	@ModelDescribe(annotation = "表单的每一行中展现字段最多的数量", runtime = true)
	private int maxFieldsNumPerRow = 0;

	/**
	 * 拦截器
	 */
	@ModelDescribe(annotation = "拦截器")
	private Interceptor interceptor;

	/**
	 * 是否有文件字段，字段中是否有引用FILE字段模板的字段
	 */
	@ModelDescribe(annotation = "是否有文件字段，字段中是否有引用FILE字段模板的字段", runtime = true)
	private boolean hasFileField;

	/**
	 * 清空业务字段的value值
	 */
	public void clearFields() {
		for (BizField field : getBizFields()) {
			field.setValue(null);
		}
	}

	/**
	 * 将数据表记录拷贝到业务对象的字段中
	 * 
	 * @param data
	 *            数据集
	 */
	public void fillFields(Map<String, Object> data) {

		FieldTemplate fieldTemplate = null;
		for (BizField field : getBizFields()) {
			if (data.containsKey(field.getCode().toUpperCase())) {
				field.setValue(data.get(field.getCode().toUpperCase()).toString());
			}

			/* 特殊处理 */
			fieldTemplate = field.getFieldTemplate();

			// 对于字段模板为BDSELECTOR的字段，需要设置字面值
			if (fieldTemplate != null && fieldTemplate.getType().equals(FieldTemplateType.BDSELECTOR)) {
				if ((fieldTemplate.getValueField() != null && fieldTemplate.getTextField() != null) && !fieldTemplate.getValueField().equals(fieldTemplate.getTextField())) {
					// 实际值与字面值不一致
					field.setText(data.get(field.getCode().toUpperCase() + "_TEXT") != null ? data.get(field.getCode().toUpperCase() + "_TEXT").toString() : "");
				} else {
					// 实际值与字面值一致
					field.setText(field.getValue());
				}
			}
		}
	}

	@Override
	public String toString() {
		StringBuilder str = new StringBuilder();
		str.append(super.toString());
		str.append("dragon.model.bizObject.BizObject:\n");
		str.append("addWindowWidth=").append(addWindowWidth).append("\t");
		str.append("addWindowHeight=").append(addWindowHeight).append("\t");
		str.append("modWindowWidth=").append(modWindowWidth).append("\t");
		str.append("modWindowHeight=").append(modWindowHeight).append("\t");
		str.append("viewWindowWidth=").append(viewWindowWidth).append("\t");
		str.append("viewWindowHeight=").append(viewWindowHeight).append("\t");
		str.append("maximizable=").append(maximizable).append("\t");
		str.append("maximize=").append(maximize).append("\t");
		str.append("pagination=").append(pagination).append("\t");
		str.append("pageSize=").append(pageSize).append("\t");
		str.append("pageList=").append(pageList).append("\t");
		str.append("remoteSort=").append(remoteSort).append("\t");
		str.append("singleSelect=").append(singleSelect).append("\t");
		str.append("rownumbers=").append(rownumbers).append("\t");
		str.append("listPage=").append(listPage).append("\t");
		str.append("treePage=").append(treePage).append("\t");
		str.append("dnd=").append(dnd).append("\t");
		str.append("dndAction=").append(dndAction).append("\t");
		str.append("addPage=").append(addPage).append("\t");
		str.append("modPage=").append(modPage).append("\t");
		str.append("viewPage=").append(viewPage).append("\t");
		str.append("depend=").append(depend).append("\t");
		str.append("dependParam=").append(dependParam).append("\t");
		str.append("maxFieldsNumPerRow=").append(maxFieldsNumPerRow).append("\t");

		str.append("\n【SQL】\n");
		if (sql != null) {
			str.append("转换前\n");
			Set<Entry<SQLType, String[]>> set = sql.entrySet();
			Iterator<Entry<SQLType, String[]>> iterator = set.iterator();
			while (iterator.hasNext()) {
				Entry<SQLType, String[]> item = iterator.next();
				str.append("\t").append(item.getKey()).append("\n");
				String[] temp = item.getValue();
				for (String sql : temp) {
					str.append(sql).append("\n");
				}
			}
			str.append("\n转换后\n");
			str.append("\tSELECT\n").append(selectSQL).append("\n");
			str.append("\tVIEW\n").append(viewSQL).append("\n");
			str.append("\tINSERT(").append(insertSQL != null ? insertSQL.length : 0).append(")\n");
			if (insertSQL != null) {
				for (String s : insertSQL) {
					str.append(s).append("\n");
				}
			}
			str.append("\tUPDATEQUERY\n").append(updateQuerySQL).append("\n");
			str.append("\tUPDATE(").append(updateSQL != null ? updateSQL.length : 0).append(")\n");
			if (updateSQL != null) {
				for (String s : updateSQL) {
					str.append(s).append("\n");
				}
			}
			str.append("\tDELETE(").append(deleteSQL != null ? deleteSQL.length : 0).append(")\n");
			if (deleteSQL != null) {
				for (String s : deleteSQL) {
					str.append(s).append("\n");
				}
			}
		}

		str.append("\n\n【bizFieldsBind】\n").append(bizFieldsBind).append("\n");

		str.append("\n【BIZFIELDS】\n");
		if (bizFields != null) {
			for (BizField bizField : bizFields) {
				str.append("bizField=").append(bizField).append("\n\n");
			}
		}

		str.append("\n【QUERYFIELDS】\n");
		if (queryFields != null) {
			for (QueryField queryField : queryFields) {
				str.append("queryField=").append(queryField).append("\n\n");
			}
		}

		str.append("\n【PROCESSES】\n");
		if (processes != null) {
			for (BizProcess process : processes) {
				str.append("process=").append(process).append("\n\n");
			}
		}

		return str.toString();
	}

	@Override
	public String toHtmlString() {
		return "<a href=\"javascript:void(0);\" onclick=\"viewMore('BizObject','" + getCode() + "');\">" + getName() + "</a>";
	}

	/**
	 * @return the listPage
	 */
	public String getListPage() {
		return listPage;
	}

	/**
	 * @param listPage
	 *            the viewPage to set
	 */
	public void setListPage(String listPage) {
		this.listPage = listPage;
	}

	/**
	 * @return the bizFields
	 */
	public List<BizField> getBizFields() {
		return bizFields;
	}

	/**
	 * 获取指定的业务字段
	 * 
	 * @param code
	 *            业务字段code
	 */
	public BizField getBizFieldByCode(String code) {
		return bizFieldsMap.get(code.toUpperCase());
	}

	/**
	 * @param bizFields
	 *            the fields to set
	 */
	public void setBizFields(List<BizField> bizFields) {
		this.bizFields = bizFields;

		// 设置bizFieldsMap，为了方便定位BizField
		if (bizFieldsMap == null) {
			bizFieldsMap = new HashMap<String, BizField>();
		} else {
			bizFieldsMap.clear();
		}
		for (BizField field : bizFields) {
			bizFieldsMap.put(field.getCode().toUpperCase(), field);
		}
	}

	/**
	 * @return the queryFields
	 */
	public List<QueryField> getQueryFields() {
		return queryFields;
	}

	/**
	 * 获取指定的查询字段
	 * 
	 * @param code
	 *            查询字段code
	 */
	public QueryField getQueryFieldByCode(String code) {
		if (queryFieldsMap == null) {
			return null;
		}

		return queryFieldsMap.get(code);
	}

	/**
	 * @param queryFields
	 *            the queryFields to set
	 */
	public void setQueryFields(List<QueryField> queryFields) {
		this.queryFields = queryFields;

		// 设置queryFieldsMap，为了方便定位QueryField
		if (queryFieldsMap == null) {
			queryFieldsMap = new HashMap<String, QueryField>();
		} else {
			queryFieldsMap.clear();
		}
		for (QueryField queryField : queryFields) {
			queryFieldsMap.put(queryField.getCode(), queryField);
		}
	}

	/**
	 * @return the processes
	 */
	public List<BizProcess> getProcesses() {
		return processes;
	}

	/**
	 * @param processes
	 *            the processes to set
	 */
	public void setProcesses(List<BizProcess> processes) {
		this.processes = processes;
	}

	/**
	 * 添加业务过程
	 * 
	 * @param process
	 */
	public void addProcess(BizProcess process) {
		List<BizProcess> processes = getProcesses();
		if (processes == null) {
			processes = new ArrayList<BizProcess>();
			setProcesses(processes);
		}
		processes.add(process);
		processes = null;
	}

	/**
	 * 根据编码获取指定的业务过程
	 * 
	 * @param code
	 * @return
	 */
	private BizProcess getProcess(String code) {
		if (processMap == null && processes != null) {
			processMap = new HashMap<String, BizProcess>();
			for (BizProcess process : processes) {
				processMap.put(process.getCode(), process);
			}
		}
		if (processMap == null) {
			return null;
		}
		return processMap.get(code);
	}

	/**
	 * @return the sql
	 */
	public Map<SQLType, String[]> getSql() {
		return sql;
	}

	/**
	 * @param sql
	 *            the sql to set
	 */
	public void setSql(Map<SQLType, String[]> sql) {
		this.sql = sql;
	}

	/**
	 * @return the pagination
	 */
	public int getPagination() {
		return pagination;
	}

	/**
	 * @param pagination
	 *            the pagination to set
	 */
	public void setPagination(int pagination) {
		this.pagination = pagination;
	}

	/**
	 * @return the pageSize
	 */
	public int getPageSize() {
		return pageSize;
	}

	/**
	 * @param pageSize
	 *            the pageSize to set
	 */
	public void setPageSize(int pageSize) {
		this.pageSize = pageSize;
	}

	/**
	 * @return the remoteSort
	 */
	public int getRemoteSort() {
		return remoteSort;
	}

	/**
	 * @param remoteSort
	 *            the remoteSort to set
	 */
	public void setRemoteSort(int remoteSort) {
		this.remoteSort = remoteSort;
	}

	/**
	 * @return the singleSelect
	 */
	public int getSingleSelect() {
		return singleSelect;
	}

	/**
	 * @param singleSelect
	 *            the singleSelect to set
	 */
	public void setSingleSelect(int singleSelect) {
		this.singleSelect = singleSelect;
	}

	/**
	 * @return the rownumbers
	 */
	public int getRownumbers() {
		return rownumbers;
	}

	/**
	 * @param rownumbers
	 *            the rownumbers to set
	 */
	public void setRownumbers(int rownumbers) {
		this.rownumbers = rownumbers;
	}

	/**
	 * @return the pageList
	 */
	public String getPageList() {
		return pageList;
	}

	/**
	 * @param pageList
	 *            the pageList to set
	 */
	public void setPageList(String pageList) {
		this.pageList = pageList;
	}

	/**
	 * @return the selectSQL
	 */
	public String getSelectSQL() {
		return selectSQL;
	}

	/**
	 * @param selectSQL
	 *            the selectSQL to set
	 */
	public void setSelectSQL(String selectSQL) {
		this.selectSQL = selectSQL;
	}

	/**
	 * @return the viewSQL
	 */
	public String getViewSQL() {
		return viewSQL;
	}

	/**
	 * @param viewSQL
	 *            the viewSQL to set
	 */
	public void setViewSQL(String viewSQL) {
		this.viewSQL = viewSQL;
	}

	/**
	 * @return the insertSQL
	 */
	public String[] getInsertSQL() {
		return insertSQL;
	}

	/**
	 * @param insertSQL
	 *            the insertSQL to set
	 */
	public void setInsertSQL(String[] insertSQL) {
		this.insertSQL = insertSQL;
	}

	/**
	 * @return the updateSQL
	 */
	public String[] getUpdateSQL() {
		return updateSQL;
	}

	/**
	 * @param updateSQL
	 *            the updateSQL to set
	 */
	public void setUpdateSQL(String[] updateSQL) {
		this.updateSQL = updateSQL;
	}

	/**
	 * @return the deleteSQL
	 */
	public String[] getDeleteSQL() {
		return deleteSQL;
	}

	/**
	 * @param deleteSQL
	 *            the deleteSQL to set
	 */
	public void setDeleteSQL(String[] deleteSQL) {
		this.deleteSQL = deleteSQL;
	}

	/**
	 * @return the bizFieldsBind
	 */
	public Map<String, List<BizField>> getBizFieldsBind() {
		return bizFieldsBind;
	}

	/**
	 * @param bizFieldsBind
	 *            the bizFieldsBind to set
	 */
	public void setBizFieldsBind(Map<String, List<BizField>> bizFieldsBind) {
		this.bizFieldsBind = bizFieldsBind;
	}

	/**
	 * @return the updateQuerySQL
	 */
	public String getUpdateQuerySQL() {
		return updateQuerySQL;
	}

	/**
	 * @param updateQuerySQL
	 *            the updateQuerySQL to set
	 */
	public void setUpdateQuerySQL(String updateQuerySQL) {
		this.updateQuerySQL = updateQuerySQL;
	}

	/**
	 * @return the depend
	 */
	public String getDepend() {
		return depend;
	}

	/**
	 * @param depend
	 *            the depend to set
	 */
	public void setDepend(String depend) {
		this.depend = depend;
	}

	/**
	 * @return the dependParam
	 */
	public String getDependParam() {
		return dependParam;
	}

	/**
	 * @param dependParam
	 *            the dependParam to set
	 */
	public void setDependParam(String dependParam) {
		this.dependParam = dependParam;

		if (dependParam != null && !StringUtils.isEmpty(dependParam)) {
			String[] temp = dependParam.split("=");
			if (temp.length == 2) {
				dependParamK = temp[0];
				dependParamV = temp[1];
			}
		}
	}

	/**
	 * @return the dependon
	 */
	public BizObject getDependon() {
		return dependon;
	}

	/**
	 * @param dependon
	 *            the dependon to set
	 */
	public void setDependon(BizObject dependon) {
		this.dependon = dependon;
	}

	/**
	 * @return the addPage
	 */
	public String getAddPage() {
		return addPage;
	}

	/**
	 * @param addPage
	 *            the addPage to set
	 */
	public void setAddPage(String addPage) {
		this.addPage = addPage;
	}

	/**
	 * @return the modPage
	 */
	public String getModPage() {
		return modPage;
	}

	/**
	 * @param modPage
	 *            the modPage to set
	 */
	public void setModPage(String modPage) {
		this.modPage = modPage;
	}

	/**
	 * @return the viewPage
	 */
	public String getViewPage() {
		return viewPage;
	}

	/**
	 * @param viewPage
	 *            the viewPage to set
	 */
	public void setViewPage(String viewPage) {
		this.viewPage = viewPage;
	}

	/**
	 * @return the dependParamK
	 */
	public String getDependParamK() {
		return dependParamK;
	}

	/**
	 * @return the dependParamV
	 */
	public String getDependParamV() {
		return dependParamV;
	}

	/**
	 * @return the dependby
	 */
	public List<BizObject> getDependby() {
		return dependby;
	}

	/**
	 * @param dependby
	 *            the dependby to set
	 */
	public void setDependby(List<BizObject> dependby) {
		this.dependby = dependby;
	}

	/**
	 * @return the addWindowWidth
	 */
	public int getAddWindowWidth() {
		return addWindowWidth;
	}

	/**
	 * @param addWindowWidth
	 *            the addWindowWidth to set
	 */
	public void setAddWindowWidth(int addWindowWidth) {
		this.addWindowWidth = addWindowWidth;
	}

	/**
	 * @return the addWindowHeight
	 */
	public int getAddWindowHeight() {
		return addWindowHeight;
	}

	/**
	 * @param addWindowHeight
	 *            the addWindowHeight to set
	 */
	public void setAddWindowHeight(int addWindowHeight) {
		this.addWindowHeight = addWindowHeight;
	}

	/**
	 * @return the modWindowWidth
	 */
	public int getModWindowWidth() {
		return modWindowWidth;
	}

	/**
	 * @param modWindowWidth
	 *            the modWindowWidth to set
	 */
	public void setModWindowWidth(int modWindowWidth) {
		this.modWindowWidth = modWindowWidth;
	}

	/**
	 * @return the modWindowHeight
	 */
	public int getModWindowHeight() {
		return modWindowHeight;
	}

	/**
	 * @param modWindowHeight
	 *            the modWindowHeight to set
	 */
	public void setModWindowHeight(int modWindowHeight) {
		this.modWindowHeight = modWindowHeight;
	}

	/**
	 * @return the viewWindowWidth
	 */
	public int getViewWindowWidth() {
		return viewWindowWidth;
	}

	/**
	 * @param viewWindowWidth
	 *            the viewWindowWidth to set
	 */
	public void setViewWindowWidth(int viewWindowWidth) {
		this.viewWindowWidth = viewWindowWidth;
	}

	/**
	 * @return the viewWindowHeight
	 */
	public int getViewWindowHeight() {
		return viewWindowHeight;
	}

	/**
	 * @param viewWindowHeight
	 *            the viewWindowHeight to set
	 */
	public void setViewWindowHeight(int viewWindowHeight) {
		this.viewWindowHeight = viewWindowHeight;
	}

	/**
	 * @return the maximizable
	 */
	public int getMaximizable() {
		return maximizable;
	}

	/**
	 * @param maximizable
	 *            the maximizable to set
	 */
	public void setMaximizable(int maximizable) {
		this.maximizable = maximizable;
	}

	/**
	 * @return the maximize
	 */
	public int getMaximize() {
		return maximize;
	}

	/**
	 * @param maximize
	 *            the maximize to set
	 */
	public void setMaximize(int maximize) {
		this.maximize = maximize;
	}

	/**
	 * @return the maxFieldsNumPerRow
	 */
	public int getMaxFieldsNumPerRow() {
		return maxFieldsNumPerRow;
	}

	/**
	 * @param maxFieldsNumPerRow
	 *            the maxFieldsNumPerRow to set
	 */
	public void setMaxFieldsNumPerRow(int maxFieldsNumPerRow) {
		this.maxFieldsNumPerRow = maxFieldsNumPerRow;
	}

	/**
	 * @return the treePage
	 */
	public String getTreePage() {
		return treePage;
	}

	/**
	 * @param treePage
	 *            the treePage to set
	 */
	public void setTreePage(String treePage) {
		this.treePage = treePage;
	}

	/**
	 * @return the interceptor
	 */
	public Interceptor getInterceptor() {
		return interceptor;
	}

	/**
	 * @param interceptor
	 *            the interceptor to set
	 */
	public void setInterceptor(Interceptor interceptor) {
		this.interceptor = interceptor;
	}

	/**
	 * @return the hasFileField
	 */
	public boolean isHasFileField() {
		return hasFileField;
	}

	/**
	 * @param hasFileField
	 *            the hasFileField to set
	 */
	public void setHasFileField(boolean hasFileField) {
		this.hasFileField = hasFileField;
	}

	/**
	 * @return the dependShow
	 */
	public int getDependShow() {
		return dependShow;
	}

	/**
	 * @param dependShow
	 *            the dependShow to set
	 */
	public void setDependShow(int dependShow) {
		this.dependShow = dependShow;
	}

	/**
	 * 判断是否需要提供 添加 功能
	 */
	public int getInsert() {
		if (getProcess("add") != null) {
			return 1;
		}
		return 0;
	}

	/**
	 * 判断是否需要提供 修改 功能
	 */
	public int getUpdate() {
		if (getProcess("mod") != null) {
			return 1;
		}
		return 0;
	}

	/**
	 * 判断是否需要提供 删除 功能
	 */
	public int getDelete() {
		if (getProcess("del") != null) {
			return 1;
		}
		return 0;
	}

	/**
	 * 判断是否需要提供 查看 功能
	 * 
	 * @return
	 */
	public int getView() {
		if (getProcess("view") != null) {
			return 1;
		}
		return 0;
	}

	/**
	 * @return the dnd
	 */
	public int getDnd() {
		return dnd;
	}

	/**
	 * @param dnd
	 *            the dnd to set
	 */
	public void setDnd(int dnd) {
		this.dnd = dnd;
	}

	/**
	 * @return the dndAction
	 */
	public String getDndAction() {
		return dndAction;
	}

	/**
	 * @param dndAction
	 *            the dndAction to set
	 */
	public void setDndAction(String dndAction) {
		this.dndAction = dndAction;
	}

}
